System for displaying a hierarchical directory

ABSTRACT

A segmented-tree system for web browser display of a selected part of a tree-structured directory of hierarchically-related entities in a computer system. In the segmented-tree design of the present system, only the amount of information necessary to render the part of the tree in which the user is interested is transmitted from a server to the browser client. The server maintains information describing the complete tree, and it serves this information to the client in segments called ‘views’. The tree state for a particular client is maintained in relatively small data strings transferred back and forth. The server is thereby enabled to handle tree requests from many clients without special synchronization or the storage of the client state. Because the client/server tree state is kept in sync as the user navigates and modifies objects in the tree, the browser display always represents the true state of the tree.

BACKGROUND OF THE INVENTION

[0001] 1. Technical Field

[0002] The present invention relates generally to hierarchicaldirectories in computer systems, and more particularly, to a system forproviding a web browser display of a selected part of a tree-structureddirectory of hierarchically-related entities in a computer system.

[0003] 2. Statement of the problem

[0004] There are presently several known “complete-tree” implementationsfor displaying a tree-structured directory of hierarchically-relatedentities via a web browser. These alternatives require blocks ofinformation representing the entire tree to be sent from a server to abrowser client. That is, the server sends everything necessary for thebrowser to render and maintain the complete tree as the user navigatesaround in it. These implementations typically involve the transfer ofsignificant amounts of data from the server to the client.

[0005] One example of a complete-tree implementation uses Java appletcontrols. Numerous commercial and freeware Java applets exist from whicha navigation tree can be implemented. However, these designs, whilequite competent, do not integrate visually with the browser as nicely asother implementations, and may require large file transfers to thebrowser. As the number of tree objects increases, so does the loadingtime, and object numbers in the hundreds show significant performancehits.

[0006] Another example of a complete-tree implementation employsJavascript controls. Numerous commercial and freeware Javascriptcontrols exist from which a navigation tree can be implemented. Thesedesigns integrate visually very well with the browser, but they mayrequire large file transfers to the browser. As the number of treeobjects increases, so does the loading time, and when a tree of interestincludes hundreds of object numbers (or more), significant performancedegradation occurs.

[0007] A further example of an existing implementation for displaying atree-structured directory is a so-called “thin-client” display. Thisimplementation requires that all tree processing be done on the serverside. The entire tree is sent to the browser as raw HTML code withformatting embedded. While this implementation keeps theclient-processing overhead down, the tree data transfer times are verylarge for large trees.

[0008] Solution to the Problem

[0009] The present invention overcomes the aforementioned problems ofthe prior art and achieves an advance in the field by providing asegmented-tree system for web browser display of a selected part of atree-structured directory of hierarchically-related entities in acomputer system. In the segmented-tree design of the present system,only the amount of information necessary to render the part of the treein which the user is interested is transmitted from a server to thebrowser client. Detailed object information (such as a list of thenode's children) is sent only for expanded nodes in the part of the treebeing displayed. The server maintains information describing thecomplete tree, and it serves this information to the client in segmentscalled ‘views’. This method offers a number of advantages over the priorart, including the fact that it requires the transfer of relativelysmall amounts of data from the server to the web browser client, keepingloading time to a minimum. For trees served over a LAN, display responseis virtually instantaneous. In addition, the present system scales verywell. There is only a slight increase in server processing time forincreased numbers of potentially displayable tree objects. Client-sideand network processing time is essentially independent of the size ofthe tree.

[0010] In the system of the present invention, the tree state for aparticular client is maintained in relatively small data stringstransferred back and forth. This enables the server to handle treerequests from many clients without special synchronization or thestorage of the client state. Because the client/server tree state iskept in sync as the user navigates and modifies objects in the tree, thebrowser display always represents the true state of the tree.Furthermore, modifications by other clients operating concurrently areincorporated in the display segments returned as a result of the otherusers' actions. In addition, the data and presentation layers of thetree can easily be kept separate, thereby providing ease of developmentand maintenance.

BRIEF DESCRIPTION OF THE DRAWINGS

[0011]FIG. 1 is a diagram illustrating interrelationships betweenelements of the present system;

[0012]FIG. 2 is a diagram showing the layout of a typical navigationpane;

[0013]FIG. 3 is a is a flowchart showing exemplary steps performed incarrying out the general method of the present system;

[0014]FIG. 4A is a diagram showing interrelationships between datastructures used in implementing the present system;

[0015]FIG. 4B shows a managed object list and one view listcorresponding to the tree structure shown in the navigation tree segmentof Table 2;

[0016]FIG. 5 is a flowchart showing exemplary steps performed inexecuting an expandable node click;

[0017]FIG. 6 is a flowchart showing exemplary steps performed inprocessing a tree descriptor string;

[0018]FIG. 7 is a flowchart showing exemplary steps performed inbuilding a tree descriptor array; and

[0019]FIG. 8 is a flowchart showing exemplary steps performed inbuilding a tree descriptor string.

DETAILED DESCRIPTION

[0020]FIG. 1 is a diagram illustrating interrelationships betweenelements of the present system. As shown in FIG. 1, the presentsegmented tree system 100 comprises browser client subsystem (‘client’)101, which is interconnected with a server 102 via a network (or othercommunication link) 111. Client 101 is typically a ‘PC’-type computersystem, which is connected to a display device 110. Client 101 includesa browser 103, which is typically a Windows Explorer® or Netscape® webbrowser. Client 101 also includes memory containing a browser page 105,which is displayed on display device 110. Browser page 105 includes anavigation pane 106, in which is contained a segment 107 of a navigabletree (‘navigation tree’), through which a user of browser 103‘navigates’ by clicking a device such as a mouse (not shown) on nodes inthe navigation tree. Server 102 includes bridge software 104, whichselectively sends segments 107 of the navigation tree to client 101, inresponse to requests effected by user navigation through the tree.

[0021] A description of terminology employed in this document isprovided below.

[0022] Terminology

[0023] Object—a software entity representing a real-world or virtualentity. Objects have specific identities, operating parameters, andrelationships to other objects that make them unique. The term is usedin this document to more specifically indicate entities displayed on auser's screen, although objects may exist in other forms.

[0024] Navigation Tree (‘tree’)—a hierarchical, visual representation ofthe relationships among a group of objects. More specifically, thenavigation tree is the entire system tree that is displayable insegments on a client system.

[0025] Managed object—an object that generally has one or more children;typically, an object that represents a network subsystem. The managedobject is displayed via a client browser as part of a navigable treerepresenting the network.

[0026] Navigation Pane—a subset of the entire tree displayed as anavigable tree segment, stored as an HTML (view) frame on a clientsystem.

[0027] Segment—a portion of an entire tree that can be displayed by abrowser.

[0028] View—the ‘segment’ of a tree that is displayed by a browser.

[0029] View List—a list of objects in a tree specific to a managedobject.

[0030] Cursor Point—the object that the user has selected by clicking onit.

[0031] Parent—an object that contains other objects in the tree. Aparent object is directly related to specific, other objects, as far asthe tree structure is concerned. The parent relationship is indicated bythe match of an object's Unique Identifier (UID) property with anotherobject's Parent Unique Identifier (ParentUID) property.

[0032] Folder—a specific type of parent object that exists only tocontain and organize other objects.

[0033] Child—an object that is contained by a parent object. A givenobject is a child of any folder that contains it. A child object has adirect relationship with a parent object. The child relationship isindicated by the match of an object's Parent Unique Identifier(ParentUID) property with another object's Unique Identifier (UID)property.

[0034] Sibling—a specific object that has an indirect relationship withanother object. The sibling relationship is indicated by the match of anobject's Parent Unique Identifier (ParentUID) property with anotherobject's Parent Unique Identifier (ParentUID) property.

[0035] Tree Descriptor String (TDS)—A string of data that describes thestate of the complete tree from the client's perspective. The clientstarts out with an unexpanded view. As the user expands parts of theview the state of all user actions is contained in the TDS.

[0036] Tree Descriptor Array (TDA)—An array of data that containsproperty information on the data items that make up the tree segment tobe displayed by the client.

[0037] The following section provides a description of the clientnavigation tree as processed by browser client subsystem 101 of thepresent system 100.

[0038] Navigation Tree

[0039]FIG. 2 shows the general layout of an exemplary ‘navigation pane’106 containing a displayed segment 107 (‘view’) of a navigation tree,from which the user selects and organizes objects. Assuming that theentire tree is too large to be displayed on display device 110,navigation pane 106 displays only a segment 107 of the tree. Navigationpane 106 is typically the leftmost frame on a browser page 105, butalternatively, it may be displayed in any suitable area of the page. Theweb browser 103 employed by the present invention uses a hierarchicaltree structure to represent objects in the user interface. The presentinvention uses a novel method to display a user-selected part of thenavigation tree. That is, only a segment of the whole tree is presentedto the browser at a time. Because the number of objects in a given treemay run into the thousands, the present segmented design provides asignificant performance improvement over the prior art. The present treestructure emulates a Windows Explorer® tree, but it is to be noted thatthe method of the present system is not limited to any particular treestructure implementation, and is operative with any type of browser thatdisplays hierarchical data. An exemplary tree employed by the presentsystem has the basic structure described below.

[0040] The ‘Network’ is the root object of the navigation tree, asindicated by the ‘Network’ icon 201 in FIG. 2. The root contains one ormore ‘managed objects’ in the system's host hierarchy, shown in FIG. 2as MO1[0] (represented by the icon ‘Subsys1’), MO2[0] (icon ‘Subsys2’),MO3[0] (icon ‘Subsys3’). Each managed object may contain other objectssuch as folders, shown as MO1[1] (icon ‘disks’), MO1[5] (icon ‘Hosts’),MO1[8] (icon ‘more hosts’), and MO1[9] (icon ‘Switch’), each of whichmay contain ‘folderized’ objects. Each of the numbers in brackets is anindex indicating the object's sequential visual position in the treebranch of the expanded managed object. Objects occupy nodes in the tree,therefore, each of the objects shown in FIG. 2 (e.g., MO1[0]-MO1[9]) islocated at a node. There are two basic categories of tree nodes,container and leaf. Container nodes are expandable, and leaf nodes arenot expandable. When a user clicks on an expandable (container) objectin tree segment (view) 107, the object's properties are displayed in acontent frame, which is well known in the art, and therefore not shownin FIG. 2. If the clicked-on object is a folder (a container node), thefolder's tree branch is expanded in accordance with the method of thepresent system, and the object's properties are displayed in the contentpane (not shown).

[0041] Implementing the Navigation Tree

[0042] The present exemplary navigation tree implementation comprises anarray of data describing the objects in the displayed tree segment, anda string of data describing the state of the navigation tree. The rootof the tree is always open. The root, as shown in FIG. 2, has a presetlabel value of “Network.” The index value (that is, the integer valueindicating its relative position in the entire tree) of the root is −1.The Unique Identification (UID) value of the root is all zeroes. Astring of data called the ‘tree descriptor string’ (TDS) 109 describesthe state of the part of the tree that is displayable at the client at agiven time on display device 110. The TDS string is passed back andforth between the client and server, and synchronizes the two withrespect to the client's tree state. An array of data, called the ‘treedescriptor array’ (TDA) 108 contains property information on the dataitems that make up the tree segment being displayed. The tree descriptorstring and the tree descriptor array are described in detail below.

[0043] Managed Objects

[0044] Objects that represent displayable subsystems or otherdisplayable entities are called ‘managed objects’ (these objects arealso referred to as ‘StorageCells’, but the term ‘managed object’ isused in this document). Each managed object in the complete tree isassigned an object index number, as follows. The index of the root is−1; the ‘object index’ of any managed object is 0; the currently openmanaged object itself is the datum from which all other object indexesare assigned; therefore, the object index of any object contained by amanaged object is its sequential position in the managed object's treebranch.

[0045] In an exemplary embodiment of the present system, managed objectshave characteristics including the following:

[0046] each managed object has a unique UID value;

[0047] managed objects are the only allowable children of the root;

[0048] each managed object is displayed in its unexpanded state unlessthe managed object is selected;

[0049] there can be only one managed object selected (that is, ‘open’)at any time; when a closed managed object is opened, any currently openmanaged object will close;

[0050] each managed object is represented in the tree by one of a set oficons which indicate the operational condition of the managed object.

[0051] Since each managed object's index value is 0, managed objects aredifferentiated by their sibling number relative to the root. Dependingupon how the tree objects are sorted, this number may change for anyspecific managed object. The first-displayed managed object is alwayssibling number 1.

[0052]FIG. 3 is a is a flowchart showing a series of exemplary stepswhich explain high-level operation of the present system. As shown inFIG. 3, at step 305, bridge program 104 in server 102 sends a treedescriptor array (TDA) 108 and a tree descriptor string (TDS) 109(possibly null) to client browser 103. At step 310, browser 103 rendersa view (on display 110) of the segment of the tree represented by TDA108 and TDS 109. Next, at step 315, a user clicks on a displayed nodewhich causes client browser 103 to send TDS 109, updated with useraction information, to bridge program 104 in server 102 (hereinafterreferred to simply as server 102). Upon receipt of the new TDS, at step320, server 102 determines the next tree segment (view) 107 to bedisplayed based on the user action indicated in the TDS. Server 102updates TDS 109 accordingly, at step 325, and sends the updated TDS backto the client browser 103. Finally, at step 330, browser 103 renders thenew view in navigation pane 106 on display 110. Table 1, below, providesan example of a navigation tree showing all of the children of themanaged object ‘Subsys 3’. The information necessary to represent acomplete tree is stored in data storage accessible to server 102, asopposed to being stored in client system 101, thus avoiding theconsumption of a potentially large amount of storage space in clientsystem 101, as well as reducing the amount of data (unnecessarily)transferred from server 102 to client 101. TABLE 1 Navigation Tree(Server Side)

[0053] Table 2, below, shows a segment 107 of the navigation tree inTable 1 that is transferred from server 102 to client 101 to provide anavigation pane 106 viewable (as a ‘view’) via browser 103 on display110. Note that the data shown in Table 2 is a subset of the informationin Table 1. More specifically, the sample tree segment in Table 2includes only managed objects and the objects which are contained inpresently open containers, that is, the objects included in nodes whichare presently expanded in the client view. Thus, it can be seen thatonly a portion of the potentially displayable tree need be transmittedto, and stored on, client system 101 to display any given tree segment.In the present example, managed object ‘Subsys3’ is the currentlyexpanded managed object. The server-side navigation tree in Table 1shows all of the children of the managed object ‘Subsys 3’, startingwith the node labeled ‘Virtual Disks’, which has an object index valueof 1. Since each of the sub-nodes under ‘Subsys 3’ is not presentlyexpanded, the client-side tree segment shown in Table 2 does not includeall of the children of the ‘Subsys 3’ object. Even though ‘Folder B’immediately follows ‘Folder A’(which has an object index value of 2),‘Folder B’ has an object index value of 16, since there are 13 presentlyunexpanded (and undisplayed) children ‘between’ ‘Folder A’ and ‘FolderB’, as indicated in Table 1. TABLE 2 Navigation Tree Segment (ClientSide)

[0054] The Tree Descriptor Array

[0055] The tree descriptor array (TDA) 108 contains information on eachtree object in the tree segment 107 that is to be displayed. The TDA 108contains the following fields, as shown in the example in Table 3,below:

[0056] Index1—an integer indicating the relative position of the objectin the tree at which the view segment starts (the ‘v’ field index in theTDS Structure Table, below);

[0057] Index2—the ‘object index’, which is an integer indicating therelative tree position of this object from its managed object (or thevalue “−1” if the object is the root object);

[0058] Data type—a string indicating the type of this object. There aretwo basic types of tree nodes, container and leaf. Container nodes areexpandable; leaf nodes are not expandable;

[0059] Condition—a string indicating the operational condition of thisobject;

[0060] State—a string indicating the state of this object, which isindicated as “open” if a container node is presently expanded, “closed”if not expanded, and “end”, if the displayed object is located at theend of a branch and cannot be further expanded;

[0061] Label—A user-friendly text string to be displayed near the screenicon for this object; and

[0062] UID—A 40-character string indicating the Universal IDentifier ofthis object.

[0063] Exemplary information including data types, conditions, andstates that can be displayed in the tree descriptor array are shown inthe following example in Table 3, which corresponds to the navigationtree segment example shown above. TABLE 3 Tree Descriptor Array ExampleNumber of array elements <16> Index1 Index2 Type Condition State LabelUID [0] −1 root “ok” open “Network” 000 . . . 000 [1] 0 man. obj. “ok”closed “Subsys 1” 000 . . . 001 [2] 0 man. obj. “ok” closed “Subsys 2”000 . . . 002 [3] 0 man. obj. “ok” open “Subsys 3” 000 . . . 003 [4] 1folder “ok” open “Virtual Disks” 000 . . . 004 [5] 2 folder “ok” closed“Folder A” 000 . . . 005 [6] 16 folder “ok” open “Folder B” 000 . . .006 [7] 17 vd “ok” closed “VD1” 000 . . . 007 [8] 20 vd “ok” open “VD2”000 . . . 008 [9] 21 vdactive “ok” end “Active” 000 . . . 009 [10]  22vdsnap “ok” end “Snap 1” 000 . . . 010 [11]  23 folder “ok” open“Presentations” 000 . . . 011 [12]  24 folder “ok” closed “Folder A” 000. . . 012 [13]  29 folder “ok” closed “Folder B” 000 . . . 013 [14]  33hardware “ok” closed “Hardware” 000 . . . 014 [15]  0 man. obj. “ok”closed “Subsys 4 000 . . . 015

[0064] The Tree Descriptor String

[0065] The tree descriptor string (TDS) 109 is an ASCII text string sentbetween the client and the server as a variable. TDS 109 completelydescribes the state (folders open or closed) and some of the structureof the displayed segment of the navigation tree. The TDS represents thehierarchical structure of the open containers in the part of the treethat is being displayed. Braces are used to delineate the hierarchicalstructure. The Navigation Tree Segment shown above in Table 2illustrates this process. The open container nodes in the above treesegment can be represented as follows: {Root {Subsys 3 {VDs {FolderB{VD2} } } {Presentations} } }

[0066] The TDS string sequence for the above tree segment is:

[0067] {Root{Subsys3{VDs{FolderB{VD2}}}{Presentations}}}

[0068] The complete TDS string is formed as shown in the followingsection.

[0069] Forming the Tree Descriptor String

[0070] There are three basic fields in the tree descriptor string (TDS),the ‘v’ field, the ‘p’ field, and the ‘{ }’ fields. The ‘v’ field is aninteger indicating the relative position of the object in the tree atwhich the view segment starts. The ‘p’ field is an integer indicatingthe relative position of the user-selected object in the tree; this isthe cursor position. The ‘{ }’ fields include a sequence of structuresdescribing expanded nodes in the tree. Several other parameters areincluded in the TDS to specify the indexes, numbers of children, andsibling numbers of each open container. Table 4, below, describes thecomplete TDS structure for the navigation tree segment in Table 2. TABLE4 TDS Structure Field v P { } Substring - Index Number-an integer -Index Number-an Sequence of { . . . } structures describing indicatingthe relative position integer indicating the expanded nodes in the tree.of the object in the tree at relative position of the Delimiter = “{” or“}” which the view segment user-selected object in the starts. tree.Each structure is formed as follows: Delimiter = “u“ Delimiter = “u”(The values “−1” = Root - UID associated with the - Object Index Number(MOindex) - object, and “0” = the open data item at that index. aninteger indicating the position of the managed object.) Hex format.object relative to its managed object. Delimiter = “{” Delimiter = “t”if Root object; Delimiter = “s” if other object. - UID associated withthe - Sibling Number-an integer data item at that index. Hexrepresenting the sibling number of this format. object under its parent.Delimiter = “p” Delimiter = “t” - Total Children-an integer representingthe total number of children under this object. Delimiter = “{” or “}”Example v-1u10000000000000000002 p22u200000000000000003{−1t4{0s3t3{1s1t2}{16s2t2} . . . }}

TDS v-1u1000000 . . . 0002p22u2000 . . .00003{−1t4{0s3t3{1s1t2}{16s2t2}{20s2t2}{23s2t2}}}

[0071] Managed Object List

[0072]FIG. 4A is a diagram showing interrelationships between severaldata structures used in implementing the present system. The presentsystem employs, for each client, a managed object list 401 thatcontains, for each managed object, a list of pointers 402, each of whichpoints to a view list 403(*) for the object represented by theparticular pointer 401. Each view list 403 contains a list of pointers404, each of which point to an object data record 405 for the objectrepresented by the particular pointer 404. Each object data record 405contains data for the respective object including the object's UID 411,label (name) 412, type 413, condition 414 (open or closed), and theobject's parent's UID 415. Managed object list 401, view list 403, anddata records 405 are stored in a data storage device accessible toserver 102, and therefore do not consume storage space in client system101.

[0073] In the example shown in FIG. 4A, the pointer for object 1 inmanaged object list 401 points (as indicated by arrow 406) to the viewlist 403(1) for object 1. Each view list 403 contains an entry for (apointer to) each of the children of the managed object represented bythe particular view list. In FIG. 4A, it can be seen that the entry forobject 1 in view list 403(1) points (as shown by pointer 407) to theobject data record 405(1) for object 1, and the entry for object n inthe same view list 403(1) points to the object data record 405(n) forobject n.

[0074]FIG. 4B shows a managed object list 401 and one view list 403corresponding to the tree structure shown in the sample navigation treesegment in Table 2. As shown in FIG. 4B, managed object list 401contains entries for each object in the sample tree segment, as well asfor the other managed objects in the client/server network. In thepresent example, it can be seen that ‘Subsys 3’ in the managed objectlist points to a corresponding view list 403(3). View list 403(3), inturn, contains a list of pointers to each of the children of the managedobject ‘Subsys 3’ that are presently expanded in the client viewdisplayed in navigation pane 106. Each entry in the view list points toa data record for the corresponding object. In the present example, theentry for ‘Folder B’ in view list 403(3) points to the data record 405for Folder B which contains information corresponding to certain of theinformation fields contained in the tree descriptor array 108 for thepresent navigation tree. Folder B's data record contains the UID for theparent of Folder B (stored in field 415), specifically, the UID for the‘Virtual Disks’ object. In addition to providing an indication of theparent object, the UID contained in field 415 also facilitates adetermination of which objects in the view list are siblings, since eachsibling will have the same parent UID.

[0075] Client Side Tree Processing

[0076] This section describes an exemplary algorithm used to render theview of the tree specified by the tree descriptor array (TDA) 108 andtree descriptor string (TDS) 109. To aid in the explanation of thealgorithm, Javascript syntax is used to represent the TDA and TDS forthe sample navigation tree segment in Table 2. Javascript DataStructures for the Sample Navigation Tree Segment //The TDS variable:var tds=“v-1u10000000000000000002p22u20000000000000000003{-1t4{0s3t3{1s1t2}{16s2t2} {20s2t2}{23s2t2}}}”; functiontreeObject(treeIndex,treeType,treeCondition,treeState,treeLabel,treeUID){ this.treeIndex = treeIndex; this.treeType = treeType;this.treeCondition = treeCondition; this.treeState = treeState;this.treeLabel = treeLabel; this.treeUID = treeUID; } //The TDA forSample Navigation Tree Segment //The tda is the action tag <!.treetda>var tda=new Array( ); tda[0]=newtreeObject(−1,“root”,“ok”,“o”,“Network”,“00000000000000000000”);tda[1]=new treeObject(0,“mo”,“ok”,“c”,“Subsys1”,“00000000000000000000”); tda[2]=newtreeObject(0,“mo”,“ok”,“c”,“Subsys 2”,“00000000000000000000”);tda[3]=new treeObject(0,“mo”,“ok”,“o”,“Subsys3”,“00000000000000000000”); tda[4]=newtreeObject(1,“foldervd”,“ok”,“o”,“VirtualDisks”,“00000000000000000000”); tda[5]=newtreeObject(2,“foldervd”,“ok”,“c”,“Folder A”,“00000000000000000000”);tda[6]=new treeObject(16,“foldervd”,“ok”,“o”,“FolderB”,“00000000000000000000”); tda[7]=newtreeObject(17,“vd”,“ok”,“c”,“VD1”,“00000000000000000000”); tda[8]=newtreeObject(20,“vd”,“ok”,“o”,“VD2”,“00000000000000000000”); tda[9]=newtreeObject(21,“vdactive”,“ok”,“e”,“Active”,“00000000000000000000”);tda[10]=new treeObject(22,“vdsnap”,“ok”,“e”,“Snap1”,“00000000000000000000”); tda[11]=newtreeObject(23,“folderhost”,“ok”,“o”,“Presentations”,“00000000000000000000”);tda[12]=new treeObject(24,“folderhost”,“ok”,“c”,“FolderA”,“00000000000000000000”); tda[13]=newtreeObject(29,“folderhost”,“ok”,“c”,“Folder B”,“00000000000000000000”);tda[14]=newtreeObject(33,“hardware”,“ok”,“c”,“Hardware”,“00000000000000000000”);tda[15]=new treeObject(0,“mo”,“ok”,“c”,“Subsys4”,“00000000000000000000”);

[0077] It should be noted that the pseudocode set forth below providesan example of how the client view may be rendered, but other programflow sequences may instead be effected to implement the method of thepresent system. In all of the algorithms set forth below, V (whichcorresponds to the ‘v’ field in the TDS Structure in Table 4 above) isan integer indicating the relative position of the object in the tree atwhich the view segment 107 starts, and P (which corresponds to the ‘p’field in Table 4) is an integer indicating the relative position of theuser-selected object in the tree (i.e., the cursor position). Thefollowing algorithm is executed by the client browser 103.

[0078] Pseudocode for Client Tree Rendering Algorithm

[0079] Validate the structure of the tree descriptor string (TDS) 109 bychecking for an equal number of opening and closing braces. Check alsothat there is one more “t” character than “s” characters.

[0080] Parse the TDS for the index value of V and assign it to aninteger variable: (vIndex=−1).

[0081] Parse the UID of V and assign it to a string variable:(vUID=“10000000000000000002”).

[0082] Parse the index value of P and assign it to an integer variable(pIndex=22).

[0083] Parse the UID of P and assign it to a string variable:(PUID=“20000000000000000003”).

[0084] Create a new integer array, nodeIndex[]. Parse the TDS for openbraces, each of which represents an open tree container node. For eachopen brace encountered, create a new array entry containing the indexvalue that immediately follows the brace's position in the TDS:(nodeIndex[i]=<index number>). Assign the total number of expanded nodes(that is, the length of the nodeIndex array) to an integer variable(nodeIndex.length).

[0085] Create a new integer array, nodeIndex[]. Parse the TDS for thecharacter “s” (each of which represents the beginning of each expandednode's sibling number.)

[0086] For each “s” encountered, create a new array entry containing thesibling number that immediately follows the s's position in the TDS.(nodeSibling[i]=<sibling number>). Because the first expanded node, theroot, has no parent, it has no sibling number. Set its nodeSibling[0]number to zero.

[0087] Create two new integer arrays, nodeChildren[] and nodePA[]. Parsethe TDS for the character “t” (each of which represents the beginning ofeach expanded node's total number of children.) For each “t”encountered, create a new array entry containing the total number ofchildren that immediately follows the t's position in the TDS:(nodeChildren[i]=<total number of children>).

[0088] As each “t” is encountered, check the brace character immediatelyfollowing the total children field. If the brace is an opening brace,create a new “preadjustment” entry in the nodePA[] array containing thevalue True. If the brace is a closing brace, create a new entry in thesecond array containing the value False.

[0089] “Preadjustment” is the process of adjusting the total childrenvalues of each expanded node to account for expanded children below it.That is, if a node has 4 children, and the next expanded node is the3^(rd) sibling, its total children value is “preadjusted” to 4−3=1,indicating that there is one sibling under the 3^(rd) one to display.

[0090] Set up a FOR loop to move through the nodeSibling U,nodeChildren[], and node PA[] arrays starting at each array's secondentry and ending at its last entry. In each cycle of the loop (that is,at each expanded node) check the nodePA[] value of the _previous_entry(that is, nodePA[i−1]). If the previous PA value is True, “preadjust”the _previous_total children value by subtracting the sibling number ofthe current entry from it:(nodeChildren[i−1]=nodeChildren[i−1]-nodeSibling[i])

[0091] When the preadjustment process is complete, four arrays exist:

[0092] (1) nodeIndex[], which contains the indexes of each expandednode;

[0093] (2) nodeSibling[], which contains the sibling numbers of eachexpanded node;

[0094] (3) nodePA[], which contains the preadjustment Boolean values foreach expanded node, and

[0095] (4) nodeChildren[], which contains the preadjusted total numberof children of each node.

[0096] Set up a FOR loop to read the tree descriptor array (TDA) 108entries from tda[0] to tda[tda.length−1]. Each entry's index value isthen tda[i].treeIndex.

[0097] Create a temporary, new array, nodeDisplay[] to contain thegraphic items representing one tree object and to be “drawn” to thenavigation tree.

[0098] Initialize a variable gtzChildren to 0.

[0099] Set up a FOR loop to move through the nodeChildren[] andnodeIndex[] arrays with an incrementor range of from j=0 toj=(nodeIndex.length −1) (that is, one less than the total number ofexpanded nodes in the TDS). In each loop, check each entry ofnodeChildren[] and nodeIndex[] and:

[0100] If the value of nodeChildren[j]>0, set variable gtzchildren=j andcontinue checking in this loop iteration.

[0101] If the value of nodeChildren[j]=0, skip to the next iteration ofthe FOR loop.

[0102] If the value of tda[i].treeIndex equals −1, store a null innodeDisplay[j] and continue with the next iteration of the loop.

[0103] If the value of tda[i].treeIndex is greater than the value ofnodeIndex[j], store a “|” character in nodeDisplay[i] and continue tothe next iteration of the FOR loop.

[0104] If the value of tda[i].treeIndex is not equal to −1 and is lessthan or equal to the value of nodeIndex[j], return to the lastnodeChildren[] entry with a value greater than 0. This entry is found atnodeChildren[gtzChildren].

[0105] Subtract 1 from the value of that children number(nodeChildren[gtzChildren]−1). If the result is greater than 0, replacethe last “|” with a “|−”, otherwise replace it with a “L” character. Theversion of the following characters appropriate for either a containeror a leaf node should be used:

[0106] After the graphic correction is made, continue with the nextiteration of the FOR loop.

[0107] Write a line of graphics represented by the contents of thenodeDisplay[] and tda[] arrays to the navigation tree frame, as follows.

[0108] Write the appropriate connecting lines, represented by thecontents of the nodeDisplay[] array, to the left of the object in thenavigation tree frame.

[0109] Write the icon for this object type into the navigation treeframe. Use the icon appropriate to the operational condition and stateof the object.

[0110] Construct the appropriate HTML anchor tag for the object. Writethe tag, along with the object label, next to the object icon in thenavigation tree frame.

[0111] If the UID of the object matches the UID contained in thevariable pUID, adjust the display to highlight this object.

[0112] Delete the nodeDisplay[] array.

[0113] Repeat the previous steps in the FOR loop initiated above untilall entries in the TDA have been processed.

[0114] Write the appropriate scroll and page buttons into the navigationtree frame. Do not display scroll or page up buttons if the tree viewpoint (the object at the top of the view) is the system. Do not displayscroll or page buttons if the last item in the view is the last item inthe tree.

[0115] [End of Client Tree Rendering Algorithm]

[0116] In an exemplary embodiment of the present system, in addition tothe TDA 108 and TDS 109, the following variables are used by the clientbrowser 103 in rendering the navigation tree: <!.schandle> //UID of openManaged Object(required for link // formation) Action tag takes theform: var schandle=“xxxxxxxxxxxxxxxxxx”; <!.treeend> //Boolean flagindicating that the current view is //the last view in the tree(required to display or //not display scroll/page buttons for views near//end of tree) Action tag takes the form: var treeEnd=true;

[0117] Link Formation

[0118] Client Javascript constructs tree object links in the form:

[0119] <a href=javascript:treeClick(linkparameters)>Tree Object Icon andLabel</a>

[0120] The function treeClick( ) dynamically creates a call to reloadthe navigation pane 106 as described below. The basic structure of thefunction itself is as follows: function treeClick(navurl,contenturl) {//this method loads the Navigation Paneparent.navpane.location.href=navurl; }

[0121] Function Calls Targeted to the Navigation Pane

[0122] ISAPI calls, with the navigation pane as the target, load thenavigation pane 106 with a new tree segment 107. There are two suchactions of interest to the present description, depending on thedisplayed object on which the user clicks: User Action Function CallClick tree /Fusion/Treecontainer?schandle=<schandle>&index containerobject =<objectindex>&uid=<objectuid>&tds=<tds> Click tree leaf/Fusion/TreeLeaf?schandle=<schandle>&index= object<objectindex>&uid=<objectuid>&tds=<tds>

[0123] Server Side Tree Processing

[0124] This section provides a description of the processing that needsto be done by the bridge (the server) to support the informationrequirements of the client 101 in offering a navigation pane 106 to auser.

[0125] General User Actions

[0126] While a client is using the navigation pane 106 of the clientview, any action taken within that pane can be generalized to severalunique actions. Each action requires the client 101 to send a uniquerequest to the server 102 along with a unique set of arguments. For eachuser action the server must follow a particular algorithm in order toprocess that user action correctly and return the correct data to theclient application that will result in an updated view in the navigationpane 106. In this section, the user action of expanding (andcontracting) a node is identified along with exemplary algorithms, alist of assumptions, the related server actions, and an example of theformat of a client request.

[0127] Expandable Node Click

[0128] The user action identified as an “expandable node click” occurs,for example, when a user moves the cursor to a specific area of thenavigation pane, which causes an expandable node to be highlighted, anddouble-clicks the left mouse button. An expandable node is defined anode in the navigation tree that has children. This type of node isidentified by an expander box at the end of its tree branch.Double-clicking on this type of node implies a request to display theproperties associated with this node in the content pane (not discussedherein) as well as to expand the node to view its children if the nodehas yet to be expanded. If the node has already been expanded,double-clicking on the node causes the node to be contracted,effectively eliminating the view of any nodes hierarchically below thenode.

[0129] Format Example

[0130] /Fusion/TreeContainer&newP=<index value>&newPUID=<uid>&TDS=<TDS>(This call builds the new View Frame)

[0131] Server Actions

[0132] (1) Build a new view frame (the HTML navigation pane 106).

[0133] (2) Update the TDS 109 (new V, new P and expansion or contractionof new P).

[0134] (3) Reload the frame set.

[0135] Assumptions

[0136] It assumed that the UID supplied with this command will be thatof an expandable node; also, if the node supplied was previouslyexpanded it will contract unless it is the root node, which always staysopen (effectively a no-op); and the reloading of the frame setconstitutes an action separate from those described in the algorithmbelow.

[0137]FIG. 5 is a flowchart showing exemplary steps performed inexecuting an expandable node click. In the description below, the stepnumbers correspond to blocks in the flowchart, some of which arerepetitively executed, as indicated by arrows which flow in bothdirections between certain of the blocks. The Find All Children functionreferenced below finds all of the children that have a given managedobject's UID as their ParentUID in the view list 403. The Find AllSiblings function finds all the siblings of a given managed object. TheFind All Siblings and Find All Children functions are straightforwardimplementations of well-known tree navigation techniques and thus arenot detailed herein.

[0138] In the following algorithm, as indicated above, P is an integerindicating the relative position of the object in the tree at which thetree segment 107 (view) starts, and V is n integer indicating therelative position of the user-selected object in the tree (i.e., thecursor position). The updated tree descriptor string 109, the new indexvalue P (New P), and the UID of the clicked node (New PUID) are receivedas arguments to the process. It should be noted that the presentalgorithm assumes that only one managed object may be expanded in aclient view at any one time.

[0139] Expandable Node Click Algorithm

[0140] Step 510

[0141] Determine whether the tree descriptor string (TDS) 109 is empty.

[0142] Step 515

[0143] If the TDS is empty, create the default TDS. To do this, set thevalue of New P to −1 and the value of New P's UID to 0. Replace thevalue in V with the value of New P and replace the value in VU with thevalue of New P's UID. This will effectively move New P to the top of thenew view 106.

[0144] Get a list of all of the managed objects (moList) from a systemobject broker or other system utility (a ‘managed object broker’ (‘mob’)is used in the presently described embodiment)(moList=mob−>getManagedObjectList( )). Set EN to 1. Set I[0] to −1. SetS[0] to 0. Set T[0] to the size of the managed object list 401. SetPA[0] to TRUE.

[0145] Build the tree descriptor array (TDA) 108 per the Building theTree Descriptor Array algorithm described below.

[0146] Build the TDS per the Building the Tree Descriptor Stringalgorithm described below. Return with success.

[0147] Step 520

[0148] If it is not empty, process the TDS per the Processing the TreeDescriptor String algorithm described below.

[0149] Step 525

[0150] Verify that the index received as an argument to this process(New P) is greater than or equal to zero. If the index is less than 0,return to Step 515. Otherwise (if the index is either greater than orequal to 0), decide if the index received as an argument to this process(New P) is greater than zero.

[0151] Step 530

[0152] If New P is equal to 0 then this is either the first expansion ofa managed object or the contraction of a previously expanded managedobject. In either case a determination of which managed object to expandor contract must be made. Using the managed object list 401 obtainedfrom executing the Processing the Tree Descriptor String algorithm,sequence through the list comparing the UID supplied as an argument (NewPUID) to this request with the UID of each managed object.

[0153] Step 535

[0154] Decide if the UID received as an argument to this process (NewPUID) was found in the managed object list 401.

[0155] Step 540

[0156] If no managed object's UID matches the supplied UID, build thedefault TDS and TDA using the instructions in Step 515. Return withsuccess.

[0157] Step 545

[0158] If a match is found initialize a temporary variable (TV) to theindex of the managed object in the managed object list plus one.

[0159] Check the value of EN (the count of indexes in the TDS).

[0160] If EN is equal to 1 this is an expansion of the managed object.Otherwise, continue at Step 545A, below (represented by block 545 inFIG. 5).

[0161] Step 560

[0162] Set the value of I[EN] to zero. Set the value of S[EN] to TV. Getthe view list 403 (the list of children of the managed object) for themanaged object by indexing down the managed object list 401 (moList) bythe value of S[EN] adjusted down by one

[0163] (moView=(moList−>at(S[EN]−1))−>getview( )). Find all the childrenwith the managed object's UID as their Parent UID in the view list 403using a Find All Children function.

[0164] Step 565

[0165] Set T[EN] to the count of the number of children found. SetPA[EN] to false. Set PA[EN−1] to TRUE. Increment EN by one.

[0166] Step 555

[0167] If EN is greater than 1 compare the value of S[1] to TV. If thereis a match then this is a contraction of New P.

[0168] Step 565

[0169] Set the value of EN to one. Set PA[EN−1] to false.

[0170] Step 560

[0171] If New P is equal to zero and the Value of EN is greater than oneand the value of S[1] is not equal to TV then a different managed objectmay already be expanded. Before expanding the managed object referred toby New P, we must contract the currently expanded one. To do this simplyset EN to 1. Then proceed with the expansion of New P: Set the value ofI[EN] to zero. Set the value of S[EN] to TV. Get the view list 403 forthe managed object indexed by the value of S[EN] adjusted down by one(moView=(moList−>at(S[EN]−1))−>getView( )). Find all the children withthe managed object's UID as their ParentUID in the view list 403 using aFind All Children function.

[0172] Step 565

[0173] Set T[EN] to the count of the number of children found. SetPA[EN] to false. Set PA[EN−1] to TRUE. Increment EN by one.

[0174] Proceed to Step 570.

[0175] Step 545A

[0176] If New P is greater than 0, then use the managed object list 401to get the view list 403 (moView) for the managed object indexed by thevalue of S[1] adjusted down by one (moView=moList−>at(S[1]−1)).

[0177] Confirm the existence of the Expandable Node (New P) in theselected view list 403 using New P and New PUID to locate the node byits UID.

[0178] If the Expandable Node was not found, build the default TDS andTDA using the instructions in Step 515. Return with success.

[0179] Once the Expandable Node is located in the view list 403, it mustbe determined whether the user request is for an expansion or acontraction. Check the value of EN (the count of indexes in the TDS). IfEN is equal to 2 this is the first expansion within a managed object.Therefore the New P's index will not be found in the current TDS.Otherwise, set an Extra Variable (EV) to 3 and a Boolean Variable FOUNDto FALSE. While the value of EV is less than the value of EN, comparethe value of New P with the value of I[EV]. If they are equal set FOUNDto TRUE. Otherwise, if New P is greater than I[EV] compare EV to EN. IfEV is less than EN increment EV and repeat this process.

[0180] If EN is equal to 2, then go to Step 560. If the value of FOUNDis FALSE, proceed to Step 560A (shown as Block 560 in FIG. 5).Otherwise, FOUND=TRUE, and proceed with the following step.

[0181] Step 555

[0182] This is a simplified case of contraction. If a contraction occursin the middle or beginning of other expansions a more rigorous algorithmmust be employed to limit the contraction properly.

[0183] Step 565

[0184] Set EN to equal EV. Set PA[EN−1] to false. Proceed to Step 570.

[0185] Step 560

[0186] If EN is equal to 2 this is the first expansion within a ManagedObject. Find all the children with the managed object's UID as theirParent UID in the view list 403 using a Find All Children function.Verify that New P is in this list of children [i.e., in the View list].If it is not, error recovery is performed. Otherwise set I[EN] to New P.Presuming that the list of children is in ascending numerical order,determine the ordinal value of New P in the list. Set S[EN] to thisvalue. Find all the children of New P in the view list 403 using a FindAll Children function.

[0187] Step 565

[0188] Set T[EN] to the count of the number of children found. SetPA[EN] to false. Increment EN by one.

[0189] Step 560

[0190] If the value of New P is greater than the value of I[EN−1], setI[EN] to New P. Find all the siblings of New P in the view list 403using the Find All Siblings function. Presuming that the list ofsiblings is in ascending numerical order, determine the ordinal value ofNew P in the list. Set S[EN] to this value. Find all the children of NewP in the view list 403 using a Find All Children function.

[0191] Step 565

[0192] Set T[EN] to the count of the number of children found. SetPA[EN] to false. Increment EN by one.

[0193] Step 560A

[0194] If the value of New P is less than the value of I[EV] initializeanother temporary variable to the value of EN (ATV=EN). While ATV isgreater than TV, I[ATV]=I[ATV−1], S[ATV]=S[ATV−1], T[ATV]=T[ATV−1],PA[ATV]=PA[ATV−1], ATV=ATV−1. Set I[EV] to New P. Find all the siblingsof New P in the view list 403 using a Find All Siblings function.Presuming that the list of siblings is in ascending numerical order,determine the ordinal value of New P in the list. Set S[EV] to thisvalue. Find all the children of New P in the view list 403 using theFind All Children function.

[0195] Step 565

[0196] Set T[EV] to the count of the number of children found. SetPA[EV] to false. Increment EN by one.

[0197] Step 570

[0198] Replace the value in P with the value of New P and replace thevalue in PU with the value of New P's UID.

[0199] Replace the value in V with the value of New P and replace thevalue in VU with the value of New P's UID. This will effectively moveNew P to the top of the new view.

[0200] Step 575

[0201] Build the TDA per the Building the Tree Descriptor Arrayalgorithm described below.

[0202] After building the TDA, verify that New P is part of the list. Ifit is not, perform error recovery.

[0203] Step 580

[0204] Build the TDS per the Building the Tree Descriptor Stringalgorithm.

[0205] Return with success.

[0206] [End of Expandable Node Click Algorithm]

[0207] Common Algorithms

[0208] When dealing with indexes into the vector of a complete managedobject tree, objects are related to each other. Some of theserelationships can easily be identified. However, the type ofrelationship is not always obvious. For instance, two adjacent entriesin the vector could have a parent/child relationship, a sibling/siblingrelationship, or no relationship. However, in terms of viewable objects,nodes having no other relationship may have a view relationship. Typesof view relationships include view/view next, view next/view, view/skipand skip/view depending upon the user action. To determine theserelationships, three common algorithms are employed: processing the treedescriptor string, building the tree descriptor array, and building thetree descriptor string. These algorithms are described below.

[0209] Processing The Tree Descriptor String

[0210]FIG. 6 is a flowchart showing exemplary steps performed inprocessing a tree descriptor string. The steps listed below areillustrated by the blocks appearing in FIG. 6. Prior to execution ofstep 605, a counter variable (EN) is initialized to zero.

[0211] Step 605

[0212] Parse V index value from the tree descriptor string (TDS) 109 andassign it to an integer variable (V=<index_value>).

[0213] Parse V's UID value from the TDS and assign it to a UID variable(VU=<VUID>).

[0214] Step 615

[0215] Parse P index value from the TDS and assign it to an integervariable (P=<index_value>).

[0216] Parse P's UID value from the TDS and assign it to a UID variable(PU=<PUID>).

[0217] Step 620

[0218] Parse the first open brace and root index and assign the rootindex to an integer variable (I[EN]=−1). Parse T and T value and assignthe T value to an integer variable (T[EN]=<T_value>). Since there is noS value set an integer variable to zero (S[EN]=0).

[0219] Step 625

[0220] Parse the next character. If it is a closing brace a booleanvariable is set to FALSE (PA[EN]=False), the counter variable isincremented by one (EN=EN +1) and parsing is complete. If the characterread is an opening brace a boolean variable is set to TRUE (PA[EN]=True)and the counter variable is incremented by one (EN=EN+1). Parsingcontinues with the next index value (I[EN]=<index value>), the S and theS value (S[EN]=<s value>), the T and the T value (T[EN]=<t value>).Parse the next character. If it is a closing brace a boolean variable isset to FALSE (PA[EN]=False) and the next character would be read.Characters continue to be read until the end of the string is reached oran opening brace is encountered. If the end of the string is reached thecounter variable is incremented by one (EN=EN+1). Otherwise processingcontinues as specified at the beginning of this paragraph.

[0221] Step 630

[0222] Get the managed object list 401 (moList) from the system objectbroker or other system utility (scList=ob−>getmanaged objectList( )) andcompare the size of the list to the first T value (T[0]).

[0223] Step 635

[0224] If they are not the same replace the T value with the new count(if (T[0]!=moList−>size( )) T[0]=moList−>size( )). [End of ProcessingThe Tree Descriptor String]

[0225] Building the Tree Descriptor Array

[0226]FIG. 7 is a flowchart showing exemplary steps performed inbuilding a tree descriptor array (TDA) 108. The steps listed below areillustrated by the blocks appearing in FIG. 7.

[0227] Step 705

[0228] First, determine the number of entries that the TDA will have.This is determined be a preset default or a user preference. Keep trackof how many entries have been made to the list and compare it to howmany are needed as an entry is added to the TDA.

[0229] Step 710

[0230] Start the TDA by adding a pointer to V.

[0231] Step 715

[0232] If V is equal to −1 (top of the tree) its children arerepresented by the list of managed objects (moList), so this list mustbe traversed first in the following algorithm before traversing aspecific view list 403.

[0233] Step 720

[0234] Likewise, if V is equal to 0, VU must be used to determine whichmanaged object in the managed object list 401 is being referred to incase the view is starting with an unexpanded sibling of the managedobject's view list 403 that is to be traversed.

[0235] If V is equal to an index from the original tree descriptorstring (TDS) 109 find all children of V. For each child, go in ascendingorder of indexes, placing the child in the TDA.

[0236] Step 730

[0237] Then compare its index with any of the indexes in the originalTDS. If the indexes match find its children and repeat the aboveprocess.

[0238] Step 735

[0239] Continue this process until all children of all expanded nodeshave been found or the TDA is full.

[0240] Step 745

[0241] If all siblings have been added and the list is not full, moveback to the previous level and continue to add siblings. Repeat thisprocess until the TDA is full or all children of V have been traversed.

[0242] If V is not equal to an index but is greater than that indexcheck V against the next index. If there are no more indexes to compareto V was not expanded and there will be no children of V to add to theTDA. If V is found to be greater than one index but less than anotherthen V was not expanded and there will be no children of V to add to theTDA.

[0243] Step 740

[0244] On the lowest level, continue to add siblings to the TDA untilall siblings have been added or the TDA is full.

[0245] If all siblings of V have been traversed or there are no siblingsof V to traverse determine if there are any siblings of V's Parent withan index higher than V. If there are, sequence in ascending order ofindexes, placing the sibling in the TDA, then compare its index with anyof the indexes in the original TDS.

[0246] Step 715

[0247] If the indexes match find its children and for each child, go inascending order of indexes, placing the child in the TDA, then comparingits index with any of the indexes in the original TDS.

[0248] Step 745

[0249] Continue this process until all children of all expanded nodeshave been found or the TDA is full. On the lowest level, continue to addsiblings to the list until all siblings have been added or the TDA isfull.

[0250] Step 750

[0251] If all siblings have been added and the TDA is not full, moveback to the previous level and continue to add siblings. Repeat thisprocess until the TDA is full or all siblings of V's Parent have beentraversed.

[0252] Step 760

[0253] Until the TDA is full, a node does not have a parent (managedobjects do not have parents) or there are no nodes left in the treerepeat the process with the parent of the just traversed node.

[0254] Step 735

[0255] As children are found the count of children for an index shouldbe checked and changed if different from what was in the previous TDS.If an expanded child's sibling index is different from what was in theprevious TDS it should be changed. In the unusual case where the TDA isnot full and the tree below V has been completely traversed, a new Vmust be found with an index lower than the current V. The node thatbecomes the new V will be based on how many view slots are left in theTDA and how the tree has been expanded above the current V. [End ofBuilding the Tree Descriptor Array]

[0256] Building the Tree Descriptor String

[0257]FIG. 8 is a flowchart showing exemplary steps performed inbuilding a tree descriptor string. The steps listed below areillustrated by the blocks appearing in FIG. 8.

[0258] Step 805

[0259] Since the TDS 109 is a string, start with a new (null) string.

[0260] Step 815

[0261] Add the letter V followed by the index value of V formatted astext in decimal.

[0262] Step 825

[0263] Add the letter U followed by the UID of V formatted as text inhexadecimal.

[0264] Step 835

[0265] Add the letter P followed by the index value of P formatted astext in decimal.

[0266] Step 840

[0267] Add the letter U followed by the UID of P formatted as text inhexadecimal.

[0268] Step 845

[0269] Add an open brace ({) followed by the value of I[0] (should be−1) formatted as text in decimal.

[0270] Step 855

[0271] Add the letter T followed by the value of T[0] formatted as textin decimal. If the value of the counter variable EN is greater than 1initialize a brace variable (BR=1) to 1 to keep track of the number ofopen braces. Otherwise add a closing brace (}) to complete the TDS.

[0272] Step 870

[0273] Initialize a temporary variable to 1 (TV=1). Add an open brace({) followed by the value of I[TV] formatted as text in decimal. Add 1to BR. Add the letter S followed by the value of S[TV] formatted as textin decimal. Add the letter T followed by the value of T[TV] formatted astext in decimal. If the value of PA[TV] is false add a closing brace andsubtract 1 from BR

[0274] Step 860

[0275] Add 1 to TV and compare it to EN.

[0276] Step 865

[0277] If they are equal, check the value of BR. If BR is greater than 0repeat the following: add a closing brace and subtract 1 from BR.

[0278] Step 860

[0279] If the value of PA[TV] is true add 1 to TV and compare it to EN.

[0280] Step 870

[0281] If TV and EN are equal there is a problem. Otherwise, repeat theabove process starting at the beginning of this paragraph.

[0282] [End of Building the Tree Descriptor String]

[0283] While preferred embodiments of the present invention have beenshown in the drawings and described above, it will be apparent to oneskilled in the art that various embodiments of the present invention arepossible. For example, the specific tree structures, data structures andformats, and algorithmic steps presented herein should not be construedso as to limit the embodiments described herein. Modification may bemade to these and other specific elements of the invention withoutdeparting from its spirit and scope as expressed in the followingclaims.

We claim:
 1. A system for transferring information in a computer networkfrom a server to a client computer, the information including aplurality of hierarchically related objects, wherein a viewable subsetof the objects is displayed on a display device connected to the clientcomputer in the form of a navigable tree having expandable nodes, theviewable subset being visible in a navigation pane on the displaydevice, the system comprising: a tree descriptor array comprisinginformation describing each of the objects to be displayed in thenavigation pane; and a tree descriptor string comprising informationdescribing a hierarchical structure of expanded nodes in the tree;wherein the tree descriptor array and the tree descriptor string aresent from the server to the client computer; and wherein the treedescriptor string comprises a list of only those said nodes which are tobe expanded and displayed on the display device.
 2. The system of claim1, further including: a managed object list comprising an entry for eachof a plurality of managed objects in the navigable tree; and a view listcomprising a plurality of indicia of object data records, each of whichrepresents a child of one of the managed objects corresponding to anentry in the managed object list; wherein each said entry in the managedobject list comprises indicia of an entry in the view list.
 3. Thesystem of claim 2, wherein each one of the object data records includeinformation comprising: a Universal Identifier for the object to which agiven said one of the object data records corresponds; and a UniversalIdentifier for the parent of the object to which a given said one of theobject data records corresponds.
 4. The system of claim 1, wherein thetree descriptor array comprises information for each object in thesubset of the objects to be displayed, including: a Universal Identifierof the object; a first index indicating the relative position of theobject in the navigable tree, at which a tree segment starts; and asecond index indicating the relative tree position of the object fromits managed object.
 5. The system of claim 4, wherein the treedescriptor array further comprises: a first string indicating whetherthe object is expandable; and a second string indicating whether theobject is presently expanded.
 6. The system of claim 1, wherein the treedescriptor string further comprises a representation of the hierarchicalstructure of open containers in the part of the tree that is beingdisplayed.
 7. The system of claim 6, wherein the tree descriptor stringfurther comprises indicia of the location of a cursor on the displaydevice.
 8. The system of claim 7, wherein the tree descriptor stringfurther comprises indicia of the state of nodes in the displayed segmentof the navigation tree including whether a node comprising a folder isopen.
 9. The system of claim 1, wherein the client computer usesinformation in the tree descriptor string to render a view that includesone expanded said nodes.
 10. The system of claim 9, wherein the clientcomputer also uses information in the tree descriptor array to render aview that includes said nodes which are to be expanded.
 11. The systemof claim 1, wherein, in response to a user of the client computerclicking on one of said expandable nodes, the client computer sendsinformation via the tree descriptor string to the server identifying thenode to be expanded.
 12. The system of claim 1, wherein the listcontained in the tree descriptor string contains a list of those saidnodes which are to be expanded and displayed on the display device. 13.A system for transferring information in a computer network from aserver to a client computer, the information including a plurality ofhierarchically related objects, wherein a viewable subset of the objectsis displayed on a display device connected to the client computer in theform of a navigable tree having expandable nodes represented bycontainer objects, the viewable subset being visible in a navigationpane on the display device, the system comprising: a tree descriptorarray comprising information describing each of the objects to bedisplayed in the navigation pane; and a tree descriptor stringcomprising information describing a hierarchical structure of saidcontainer objects that are open; wherein the tree descriptor array andthe tree descriptor string are sent from the server to the clientcomputer; and wherein the tree descriptor string contains a list of onlythose said container objects which have been opened.
 14. The system ofclaim 13, further including: a managed object list comprising an entryfor each of a plurality of managed objects in the navigable tree; and aview list comprising a plurality of indicia of object data records, eachof which represents a child of one of the managed objects correspondingto an entry in the managed object list; wherein each said entry in themanaged object list comprises indicia of an entry in the view list. 15.The system of claim 14, wherein each one of the object data recordsinclude information comprising: a Universal Identifier for the object towhich a given said one of the object data records corresponds; and aUniversal Identifier for the parent of the object to which a given saidone of the object data records corresponds.
 16. The system of claim 13,wherein the tree descriptor array comprises information for each objectin the subset of the objects to be displayed, including: a UniversalIdentifier of the object; a first index indicating the relative positionof the object in the navigable tree, at which a tree segment starts; anda second index indicating the relative tree position of the object fromits managed object.
 17. The system of claim 16, wherein the treedescriptor array further comprises: a first string indicating whetherthe object is expandable; and a second string indicating whether theobject is presently expanded.
 18. The system of claim 13, wherein thetree descriptor string further comprises a representation of thehierarchical structure of open containers in the part of the tree thatis being displayed.
 19. The system of claim 18, wherein the treedescriptor string further comprises indicia of the location of a cursoron the display device.
 20. A method for transferring information in acomputer network from a server to a client computer, the informationincluding a plurality of hierarchically related objects, wherein aviewable subset of the objects is displayed on a display deviceconnected to the client computer in the form of a navigable tree havingexpandable nodes, the viewable subset being visible in a navigation paneon the display device, the method comprising the steps of: sending, fromthe client computer to the server, tree descriptor informationdescribing a hierarchical structure of the nodes that are to beexpanded; determining a tree segment to be displayed in the navigationpane in response to the tree descriptor information received from theclient computer; and sending, from the server to the client computer, alist of each of the objects in the tree segment to be displayed, andinformation describing each of the objects to be displayed; wherein saidtree descriptor information comprises a list of only the nodes that areto be expanded.
 21. The method of claim 20, wherein said informationdescribing each of the objects to be displayed comprises informationincluding: a Universal Identifier of the object; a first indexindicating the relative position of the object in the navigable tree, atwhich a tree segment starts; and a second index indicating the relativetree position of the object from its managed object.
 22. The system ofclaim 21, wherein said information describing each of the objects to bedisplayed further comprises: a first string indicating whether theobject is expandable; and a second string indicating whether the objectis presently expanded.
 23. The system of claim 20, wherein the treedescriptor information further comprises a representation of thehierarchical structure of open containers in the part of the tree thatis being displayed.
 24. The system of claim 23, wherein the treedescriptor information further comprises indicia of the location of acursor on the display device.
 25. The system of claim 24, wherein thetree descriptor information further comprises indicia of the state ofnodes in the displayed segment of the navigation tree including whethera node comprising a folder is open.
 26. The method of claim 20, furthercomprising the step of initially sending, in response to a user of theclient computer clicking on one of said expandable nodes, informationidentifying the node to be expanded.
 27. A method for transferringinformation in a computer network from a server to a client computer,the information including a plurality of hierarchically related objects,wherein a viewable subset of the objects is displayed on a displaydevice connected to the client computer in the form of a navigable treehaving expandable nodes, the viewable subset being visible in anavigation pane on the display device, the method comprising the stepsof: generating a tree descriptor array comprising information describingeach of the objects to be displayed in the navigation pane; generating atree descriptor string comprising information describing a hierarchicalstructure of expanded nodes in the tree; and sending the tree descriptorarray and the tree descriptor string from the server to the clientcomputer; wherein the tree descriptor string comprises a list of onlythose said nodes which are to be expanded and displayed on the displaydevice.